import request from '@/utils/request'

/**
 * 上传头像文件（无需认证）
 * @param {FormData} formData - 包含头像文件的FormData
 * @returns {Promise} 响应结果
 */
export function uploadAvatarFile(formData) {
  return request({
    url: '/upload/avatar',
    method: 'post',
    data: formData,
    headers: {
      'Content-Type': 'multipart/form-data'
    },
    timeout: 30000 // 30秒超时
  })
}

/**
 * 上传并更新用户头像（需要认证）
 * @param {FormData} formData - 包含头像文件的FormData
 * @returns {Promise} 响应结果
 */
export function uploadUserAvatar(formData) {
  return request({
    url: '/user/avatar/upload',
    method: 'post',
    data: formData,
    headers: {
      'Content-Type': 'multipart/form-data'
    },
    timeout: 30000 // 30秒超时
  })
}

/**
 * 获取当前用户头像信息
 * @returns {Promise} 响应结果
 */
export function getCurrentUserAvatar() {
  return request({
    url: '/user/avatar/current',
    method: 'get'
  }).catch(error => {
    // 如果是404，说明用户还没有设置头像，返回默认头像
    if (error.response?.status === 404) {
      console.log('用户还没有设置头像，使用默认头像')
      return {
        data: {
          avatarUrl: '/default-avatar.svg',
          userId: null,
          nickname: '用户',
          username: 'user'
        }
      }
    }
    // 如果是401未授权，返回默认头像
    if (error.response?.status === 401) {
      console.log('用户未登录，使用默认头像')
      return {
        data: {
          avatarUrl: '/default-avatar.svg',
          userId: null,
          nickname: '游客',
          username: 'guest'
        }
      }
    }
    // 对于其他错误，继续抛出
    console.warn('获取用户头像失败:', error.message)
    throw error
  })
}

/**
 * 获取指定用户头像信息
 * @param {number} userId - 用户ID
 * @returns {Promise} 响应结果
 */
export function getUserAvatar(userId) {
  if (!userId) {
    return Promise.resolve({
      data: {
        avatarUrl: '/default-avatar.svg',
        userId: userId,
        nickname: '用户',
        username: 'user'
      }
    })
  }

  return request({
    url: `/user/avatar/user/${userId}`,
    method: 'get'
  }).catch(error => {
    // 如果是404，说明用户还没有设置头像，返回默认头像
    if (error.response?.status === 404) {
      console.log(`用户${userId}还没有设置头像，使用默认头像`)
      return {
        data: {
          avatarUrl: '/default-avatar.svg',
          userId: userId,
          nickname: '用户',
          username: 'user'
        }
      }
    }
    // 对于其他错误，继续抛出
    console.warn('获取用户头像失败:', error.message)
    throw error
  })
}

/**
 * 重置用户头像为默认头像
 * @returns {Promise} 响应结果
 */
export function resetUserAvatar() {
  return request({
    url: '/user/avatar/reset',
    method: 'post'
  })
}

/**
 * 获取头像文件信息
 * @param {string} path - 头像文件路径（格式：year/month/day/filename）
 * @returns {Promise} 响应结果
 */
export function getAvatarFileInfo(path) {
  return request({
    url: `/files/info/avatar/${path}`,
    method: 'get'
  })
}

/**
 * 构建头像访问URL
 * @param {string} avatarUrl - 后端返回的头像路径
 * @returns {string} 完整的头像访问URL
 */
export function buildAvatarUrl(avatarUrl) {
  console.log('buildAvatarUrl输入:', avatarUrl) // 调试日志
  
  if (!avatarUrl) {
    console.log('没有头像URL，使用默认头像')
    return '/default-avatar.svg' // 默认头像
  }
  
  if (avatarUrl.startsWith('http')) {
    console.log('已经是完整URL:', avatarUrl)
    return avatarUrl // 已经是完整URL
  }
  
  if (avatarUrl.startsWith('/api')) {
    // 在开发环境下通过vite代理访问，生产环境需要完整URL
    if (import.meta.env.DEV) {
      console.log('开发环境，通过vite代理访问:', avatarUrl)
      return avatarUrl // 开发环境通过vite代理
    } else {
      const fullUrl = `${import.meta.env.VITE_API_BASE_URL || 'http://localhost:8080'}${avatarUrl}`
      console.log('生产环境，构建完整URL:', fullUrl)
      return fullUrl
    }
  }
  
  // 如果是相对路径，添加/api前缀
  if (avatarUrl.startsWith('/files/avatar/')) {
    const fullPath = `/api${avatarUrl}`
    if (import.meta.env.DEV) {
      console.log('相对路径，添加/api前缀:', fullPath)
      return fullPath
    } else {
      const fullUrl = `${import.meta.env.VITE_API_BASE_URL || 'http://localhost:8080'}${fullPath}`
      console.log('相对路径，构建完整URL:', fullUrl)
      return fullUrl
    }
  }
  
  // 如果是默认头像
  if (avatarUrl.includes('default') || avatarUrl.includes('avatar.svg')) {
    console.log('使用默认头像')
    return '/default-avatar.svg'
  }
  
  console.log('未知格式，直接返回:', avatarUrl)
  return avatarUrl
}

/**
 * 验证头像文件
 * @param {File} file - 要验证的文件
 * @returns {Object} 验证结果
 */
export function validateAvatarFile(file) {
  const result = {
    valid: true,
    message: ''
  }
  
  // 检查文件类型
  const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/bmp', 'image/webp']
  if (!allowedTypes.includes(file.type)) {
    result.valid = false
    result.message = '不支持的头像格式，支持格式：jpg, jpeg, png, gif, bmp, webp'
    return result
  }
  
  // 检查文件大小（5MB = 5 * 1024 * 1024 bytes）
  const maxSize = 5 * 1024 * 1024
  if (file.size > maxSize) {
    result.valid = false
    result.message = '头像文件大小不能超过5MB'
    return result
  }
  
  return result
}

/**
 * 压缩图片文件
 * @param {File} file - 原始图片文件
 * @param {Object} options - 压缩选项
 * @returns {Promise<File>} 压缩后的文件
 */
export function compressImage(file, options = {}) {
  return new Promise((resolve, reject) => {
    const {
      maxWidth = 800,
      maxHeight = 800,
      quality = 0.8
    } = options
    
    const canvas = document.createElement('canvas')
    const ctx = canvas.getContext('2d')
    const img = new Image()
    
    img.onload = () => {
      // 计算新的尺寸
      let { width, height } = img
      
      if (width > maxWidth || height > maxHeight) {
        const ratio = Math.min(maxWidth / width, maxHeight / height)
        width *= ratio
        height *= ratio
      }
      
      canvas.width = width
      canvas.height = height
      
      // 绘制压缩后的图片
      ctx.drawImage(img, 0, 0, width, height)
      
      // 转换为Blob
      canvas.toBlob((blob) => {
        if (blob) {
          const compressedFile = new File([blob], file.name, {
            type: file.type,
            lastModified: Date.now()
          })
          resolve(compressedFile)
        } else {
          reject(new Error('图片压缩失败'))
        }
      }, file.type, quality)
    }
    
    img.onerror = () => {
      reject(new Error('图片加载失败'))
    }
    
    img.src = URL.createObjectURL(file)
  })
}

/**
 * 检查头像API是否可用
 * @returns {Promise<boolean>} API是否可用
 */
export async function checkAvatarApiAvailability() {
  try {
    // 尝试调用获取当前用户头像接口
    await getCurrentUserAvatar()
    return true
  } catch (error) {
    // 如果是404或401，认为API不可用
    if (error.response?.status === 404 || error.response?.status === 401) {
      return false
    }
    // 其他错误也认为API不可用
    return false
  }
} 